/**
 * 行程时间工具函数
 * 用于处理行程时间相关的逻辑
 * 包括行程设置和高阶模式的时间判断
 */

/**
 * 获取当前时间字符串，格式为 HH:MM
 * @returns {string} 当前时间字符串
 */
function getCurrentTimeString() {
  const now = new Date()
  const hours = now.getHours().toString().padStart(2, '0')
  const minutes = now.getMinutes().toString().padStart(2, '0')
  return `${hours}:${minutes}`
}

/**
 * 将时间字符串转换为分钟数
 * @param {string} timeString - 时间字符串，格式为 HH:MM
 * @returns {number} 分钟数
 */
function convertTimeToMinutes(timeString) {
  if (timeString === '--:--') return -1

  const parts = timeString.split(':')
  if (parts.length !== 2) return -1

  const hours = parseInt(parts[0], 10)
  const minutes = parseInt(parts[1], 10)

  if (isNaN(hours) || isNaN(minutes)) return -1

  return hours * 60 + minutes
}

/**
 * 检查当前时间是否在指定的时间范围内
 * @param {string} startTime - 开始时间，格式为 HH:MM
 * @param {string} endTime - 结束时间，格式为 HH:MM
 * @param {boolean} crossZeroMode - 是否跨零点模式
 * @returns {boolean} 当前时间是否在时间范围内
 */
function isCurrentTimeInRange(startTime, endTime, crossZeroMode = false) {
  // 如果开始时间或结束时间未设置，返回false
  if (startTime === '--:--' || endTime === '--:--') {
    return false
  }

  const currentTimeString = getCurrentTimeString()

  const currentMinutes = convertTimeToMinutes(currentTimeString)
  const startMinutes = convertTimeToMinutes(startTime)
  const endMinutes = convertTimeToMinutes(endTime)

  // 如果任何时间转换失败，返回false
  if (currentMinutes === -1 || startMinutes === -1 || endMinutes === -1) {
    return false
  }

  // 处理跨零点情况
  if (crossZeroMode && endMinutes <= startMinutes) {
    // 跨零点模式：如果当前时间大于等于开始时间或小于等于结束时间，则在范围内
    return currentMinutes >= startMinutes || currentMinutes <= endMinutes
  } else {
    // 非跨零点模式：如果当前时间在开始时间和结束时间之间，则在范围内
    return currentMinutes >= startMinutes && currentMinutes <= endMinutes
  }
}

/**
 * 获取当前正在运行的行程
 * @param {Array} timerTasks - 行程任务列表
 * @returns {Object|null} 当前正在运行的行程，如果没有则返回null
 */
function getCurrentRunningSchedule(timerTasks) {
  if (!timerTasks || !Array.isArray(timerTasks)) {
    return null
  }

  // 筛选出已启用的行程
  const enabledTasks = timerTasks.filter(task => task.enabled)

  // 查找当前时间所在的行程
  for (const task of enabledTasks) {
    if (isCurrentTimeInRange(task.time, task.endTime, task.crossZeroMode)) {
      return task
    }
  }

  return null
}

/**
 * 获取当前星期几（0-6，0表示周一，6表示周日）
 * @returns {number} 当前星期几
 */
function getCurrentDayOfWeek() {
  const now = new Date()
  // getDay()返回0-6，0表示周日，6表示周六
  // 转换为0表示周一，6表示周日
  const day = now.getDay()
  return day === 0 ? 6 : day - 1
}

/**
 * 检查当前时间是否在高阶模式曲线的运行时间范围内
 * @param {Array} curves - 高阶模式曲线列表
 * @returns {Object|null} 当前正在运行的曲线，如果没有则返回null
 */
function getCurrentRunningCurve(curves) {
  if (!curves || !Array.isArray(curves)) {
    return null
  }

  // 获取当前星期几（0-6，0表示周一，6表示周日）
  const currentDayOfWeek = getCurrentDayOfWeek()

  // 筛选出已启用的曲线
  const enabledCurves = curves.filter(curve => curve.enabled)

  // 查找当前时间所在的曲线
  for (const curve of enabledCurves) {
    // 检查当前星期是否在曲线的运行周期内
    if (curve.weekdays && curve.weekdays[currentDayOfWeek]) {
      // 从曲线数据中提取开始和结束时间
      const timePoints = extractTimePointsFromCurve(curve.data)
      if (timePoints && timePoints.startTime && timePoints.endTime) {
        // 检查当前时间是否在曲线的时间范围内
        if (isCurrentTimeInRange(timePoints.startTime, timePoints.endTime, false)) {
          return {
            curve: curve,
            startTime: timePoints.startTime,
            endTime: timePoints.endTime,
          }
        }
      }
    }
  }

  return null
}

/**
 * 从曲线数据中提取开始和结束时间
 * @param {Object} curveData - 曲线数据
 * @returns {Object} 包含开始和结束时间的对象
 */
function extractTimePointsFromCurve(curveData) {
  if (!curveData) return null

  // 获取所有时间点
  const timePoints = []
  ;['red', 'green', 'blue', 'white'].forEach(color => {
    if (Array.isArray(curveData[color])) {
      curveData[color].forEach(point => {
        if (point.time !== undefined) {
          timePoints.push(point.time)
        }
      })
    }
  })

  // 如果没有时间点，返回null
  if (timePoints.length === 0) return null

  // 排序并去重
  const uniqueTimePoints = [...new Set(timePoints)].sort((a, b) => a - b)

  // 获取最小和最大时间点
  const minTime = uniqueTimePoints[0]
  const maxTime = uniqueTimePoints[uniqueTimePoints.length - 1]

  // 转换为HH:MM格式
  const startTime = formatTimeFromHours(minTime)
  const endTime = formatTimeFromHours(maxTime)

  return { startTime, endTime }
}

/**
 * 将小时数转换为HH:MM格式
 * @param {number} hours - 小时数（可以是小数）
 * @returns {string} HH:MM格式的时间字符串
 */
function formatTimeFromHours(hours) {
  const totalMinutes = Math.round(hours * 60)
  const h = Math.floor(totalMinutes / 60)
    .toString()
    .padStart(2, '0')
  const m = (totalMinutes % 60).toString().padStart(2, '0')
  return `${h}:${m}`
}

module.exports = {
  getCurrentTimeString,
  convertTimeToMinutes,
  isCurrentTimeInRange,
  getCurrentRunningSchedule,
  getCurrentDayOfWeek,
  getCurrentRunningCurve,
  extractTimePointsFromCurve,
  formatTimeFromHours,
}
